Python Django-autentisering: Bemästra anpassade användarmodeller för globala applikationer

Djangos inbyggda autentiseringssystem är en kraftfull utgångspunkt för många webbapplikationer. Men när din applikation skalas och blir mer komplex, särskilt för en global publik, kanske standardanvändarmodellen inte räcker till. Det är här anpassade användarmodeller kommer in i bilden och erbjuder större flexibilitet och kontroll över användardata och autentiseringsprocesser. Den här omfattande guiden leder dig genom processen att skapa och implementera anpassade användarmodeller i Django, vilket säkerställer att din applikation är väl rustad för att hantera olika användarkrav och säkerhetsöverväganden.

Varför använda en anpassad användarmodell?

Standard-Django-användarmodellen är utformad med vanliga attribut som användarnamn, lösenord, e-post, förnamn och efternamn. Även om den är lämplig för enkla applikationer, räcker den ofta inte till när du behöver:

• Lagra ytterligare användarinformation: Tänk på en global e-handelsplattform som behöver lagra användarinställningar, adresser i olika format, föredragna valutor eller språkinställningar. Dessa ligger utanför standardmodellens omfattning.
• Ändra autentiseringsfältet: Kanske vill du autentisera användare med deras e-postadress istället för ett användarnamn, eller implementera multifaktorautentisering som kräver ytterligare fält.
• Integrera med befintliga databaser: Om du integrerar en Django-applikation med en befintlig databas som har ett annat användarschema, kan du med en anpassad användarmodell mappa din modell till den befintliga datastrukturen.
• Förbättra säkerheten: Anpassade modeller ger större kontroll över lösenordshashning, mekanismer för återställning av lösenord och andra säkerhetsrelaterade aspekter.
• Implementera olika användarroller: Att lagra rollbaserad åtkomstkontroll (RBAC) -data direkt i modellen (eller referera till den) ger mer flexibel och explicit kontroll än generiska grupper och behörigheter.

Att använda en anpassad användarmodell ger ett rent och underhållsbart sätt att utöka användarprofilen utan att ändra Djangos kärnautentiseringssystem direkt. Det är en bästa praxis för alla projekt som förutser framtida tillväxt eller kräver specialiserad användardata.

När ska man implementera en anpassad användarmodell?

Den bästa tiden att implementera en anpassad användarmodell är i början av ditt projekt. Att ändra användarmodellen i en produktionsmiljö kan vara komplicerat och potentiellt dataskadande. Om ditt projekt redan är på gång, överväg noga konsekvenserna och skapa en robust migreringsplan innan du gör några ändringar.

Här är en allmän riktlinje:

• Börja med en anpassad användarmodell: Om du förutser något behov av utökad användarinformation eller anpassad autentiseringslogik.
• Överväg migrering noggrant: Om du redan har ett Django-projekt igång med användare och bestämmer dig för att byta till en anpassad modell. Säkerhetskopiera din databas och förstå migreringsprocessen grundligt.

Skapa en anpassad användarmodell

Det finns två huvudmetoder för att skapa en anpassad användarmodell i Django:

1. AbstractBaseUser: Detta tillvägagångssätt ger dig fullständig kontroll över användarmodellen. Du definierar alla fält, inklusive användarnamn, lösenord, e-post och alla anpassade fält du behöver.
2. AbstractUser: Detta tillvägagångssätt ärver från Djangos standardanvändarmodell och låter dig lägga till eller åsidosätta befintliga fält. Detta är enklare om du bara behöver lägga till några extra fält.

1. Använda AbstractBaseUser (Fullständig kontroll)

Detta är det mest flexibla alternativet som låter dig definiera hela användarmodellen från början. Det ger störst kontroll över användardatastrukturen och autentiseringsprocessen. Här är hur:

Steg 1: Skapa en anpassad användarmodell

I din Django-app (t.ex. 'accounts'), skapa en `models.py`-fil och definiera din anpassade användarmodell som ärver från `AbstractBaseUser` och `PermissionsMixin`:

            from django.db import models
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager

class CustomUserManager(BaseUserManager):
    def create_user(self, email, password=None, **extra_fields):
        if not email:
            raise ValueError('The Email field must be set')
        email = self.normalize_email(email)
        user = self.model(email=email, **extra_fields)
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, email, password, **extra_fields):
        extra_fields.setdefault('is_staff', True)
        extra_fields.setdefault('is_superuser', True)
        extra_fields.setdefault('is_active', True)

        if extra_fields.get('is_staff') is not True:
            raise ValueError('Superuser must have is_staff=True.')
        if extra_fields.get('is_superuser') is not True:
            raise ValueError('Superuser must have is_superuser=True.')

        return self.create_user(email, password, **extra_fields)

class CustomUser(AbstractBaseUser, PermissionsMixin):
    email = models.EmailField(unique=True, verbose_name='email address')
    first_name = models.CharField(max_length=150, blank=True)
    last_name = models.CharField(max_length=150, blank=True)
    is_staff = models.BooleanField(default=False)
    is_active = models.BooleanField(default=True)
    date_joined = models.DateTimeField(auto_now_add=True)

    # Custom fields (Example: preferred language, timezone, etc.)
    preferred_language = models.CharField(max_length=10, default='en', choices=[('en', 'English'), ('fr', 'French'), ('es', 'Spanish')])
    timezone = models.CharField(max_length=50, default='UTC')

    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = [] # Required when creating a superuser

    objects = CustomUserManager()

    def __str__(self):
        return self.email

            

              
                Copy
              
            
          

Förklaring:

• CustomUserManager: Den här klassen krävs för att hantera din anpassade användarmodell. Den hanterar skapandet av användare och superanvändare. `normalize_email` är viktigt för att säkerställa e-postkonsistens över olika språk och inmatningsmetoder.
• CustomUser: Detta är din anpassade användarmodell.
• `email = models.EmailField(unique=True, verbose_name='email address')`: Definierar e-postfältet som den unika identifieraren för användaren. Att använda `unique=True` säkerställer att varje användare har en unik e-postadress. Det utförliga namnet förbättrar administratörsgränssnittet.
• `first_name`, `last_name`: Standardfält för att lagra användarens namn. `blank=True` tillåter att dessa fält är tomma.
• `is_staff`, `is_active`: Standardfält för att kontrollera användaråtkomst till administratörspanelen och kontoaktivering.
• `date_joined`: Registrerar datumet då användarkontot skapades.
• `preferred_language`, `timezone`: Exempel på anpassade fält för att lagra användarinställningar. Argumentet `choices` begränsar de möjliga språkalternativen. Detta är avgörande för en global applikation. Tidszon är också viktigt för lokalisering.
• `USERNAME_FIELD = 'email'`: Anger att e-postfältet ska användas som användarnamn för autentisering.
• `REQUIRED_FIELDS = []`: Anger vilka fält som krävs när du skapar en superanvändare med kommandot `createsuperuser`. I det här fallet krävs inga ytterligare fält utöver e-postadressen och lösenordet.
• `objects = CustomUserManager()`: Tilldelar den anpassade användarhanteraren till modellen.
• `__str__(self)`: Definierar hur användarobjektet representeras som en sträng (t.ex. i administratörspanelen).

Steg 2: Uppdatera `settings.py`

Tala om för Django att använda din anpassade användarmodell genom att lägga till följande rad i din `settings.py`-fil:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Ersätt `accounts` med namnet på din app där du definierade `CustomUser`-modellen.

Steg 3: Skapa och tillämpa migreringar

Kör följande kommandon för att skapa och tillämpa migreringarna:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

Detta kommer att skapa en ny databastabell för din anpassade användarmodell.

Steg 4: Använda den anpassade användarmodellen

Nu kan du använda din anpassade användarmodell i dina vyer, mallar och andra delar av din applikation. Till exempel, för att skapa en ny användare:

            from accounts.models import CustomUser

user = CustomUser.objects.create_user(email='user@example.com', password='password123', first_name='John', last_name='Doe')
            

              
                Copy
              
            
          

2. Använda AbstractUser (Lägga till i standardmodellen)

Detta tillvägagångssätt är enklare om du bara behöver lägga till några extra fält till Djangos standardanvändarmodell. Den ärver alla befintliga fält och metoder från `AbstractUser`. Detta kan vara enklare för enklare anpassning.

Steg 1: Skapa en anpassad användarmodell

I din Django-apps `models.py`-fil, definiera din anpassade användarmodell som ärver från `AbstractUser`:

            from django.contrib.auth.models import AbstractUser
from django.db import models

class CustomUser(AbstractUser):
    # Add extra fields here
    phone_number = models.CharField(max_length=20, blank=True, verbose_name='Phone Number')
    profile_picture = models.ImageField(upload_to='profile_pictures/', blank=True)
    # Custom fields (Example: preferred currency, address format, etc.)
    preferred_currency = models.CharField(max_length=3, default='USD', choices=[('USD', 'US Dollar'), ('EUR', 'Euro'), ('JPY', 'Japanese Yen')])
    address_format = models.CharField(max_length=50, blank=True, help_text='e.g., "Name, Street, City, Zip, Country"')

    def __str__(self):
        return self.username

            

              
                Copy
              
            
          

Förklaring:

• CustomUser: Detta är din anpassade användarmodell som ärver från `AbstractUser`.
• `phone_number`, `profile_picture`: Exempelfält att lägga till i användarmodellen. `upload_to` anger var profilbilder ska lagras.
• `preferred_currency`, `address_format`: Exempel på anpassade fält som är relevanta för globala applikationer. Olika länder har drastiskt olika adressformat.
• `__str__(self)`: Definierar hur användarobjektet representeras som en sträng (t.ex. i administratörspanelen). Här används användarnamnet.

Steg 2: Uppdatera `settings.py`

Samma som tidigare, tala om för Django att använda din anpassade användarmodell genom att lägga till följande rad i din `settings.py`-fil:

            AUTH_USER_MODEL = 'accounts.CustomUser'
            

              
                Copy
              
            
          

Steg 3: Skapa och tillämpa migreringar

Kör följande kommandon för att skapa och tillämpa migreringarna:

            python manage.py makemigrations
python manage.py migrate
            

              
                Copy
              
            
          

Steg 4: Använda den anpassade användarmodellen

Du kan nu komma åt de tillagda fälten när du arbetar med användarobjekt:

            from accounts.models import CustomUser

user = CustomUser.objects.create_user(username='johndoe', password='password123', email='john.doe@example.com')
user.phone_number = '+15551234567'
user.preferred_currency = 'EUR'
user.save()
            

              
                Copy
              
            
          

Bästa praxis för anpassade användarmodeller i globala applikationer

När du implementerar anpassade användarmodeller för applikationer som riktar sig till en global publik, bör du tänka på följande bästa praxis:

1. Internationalisering och lokalisering (i18n & l10n)

Lagra lokal specifik data: Utforma din modell för att rymma olika kulturella normer och dataformat. Lagra datum, tider, siffror och adresser på ett lokalkänsligt sätt.

Exempel:

            from django.utils import timezone

class CustomUser(AbstractUser):
    #...
    date_of_birth = models.DateField(blank=True, null=True)

    def get_localized_date_of_birth(self, language_code):
        if self.date_of_birth:
            return timezone.localtime(timezone.make_aware(datetime.datetime.combine(self.date_of_birth, datetime.time.min))).strftime('%x')  # Format according to the locale
        return None
            

              
                Copy
              
            
          

2. Tidszonhantering

Lagra och hantera alltid tidszoner korrekt. Lagra tidszoninformation i användarmodellen och använd den för att visa datum och tider i användarens lokala tidszon.

Exempel:

            from django.utils import timezone

class CustomUser(AbstractUser):
    #...
    timezone = models.CharField(max_length=50, default='UTC')

    def get_localized_time(self, datetime_obj):
        user_timezone = pytz.timezone(self.timezone)
        return timezone.localtime(datetime_obj, user_timezone)
            

              
                Copy
              
            
          

3. Adressformatering

Adressformat varierar kraftigt mellan länder. Implementera ett flexibelt adresssystem som gör att användare kan ange sin adress i rätt format för sin plats. Överväg att använda ett bibliotek eller en tjänst från tredje part för att hantera adressvalidering och formatering.

Exempel:

            class CustomUser(AbstractUser):
    #...
    country = models.CharField(max_length=50, blank=True)
    address_line_1 = models.CharField(max_length=255, blank=True)
    address_line_2 = models.CharField(max_length=255, blank=True)
    city = models.CharField(max_length=100, blank=True)
    postal_code = models.CharField(max_length=20, blank=True)

    def get_formatted_address(self):
        # Implement logic to format address based on country
        if self.country == 'US':
            return f'{self.address_line_1}\n{self.address_line_2}\n{self.city}, {self.postal_code}, {self.country}'
        elif self.country == 'GB':
            return f'{self.address_line_1}\n{self.address_line_2}\n{self.city}\n{self.postal_code}\n{self.country}'
        else:
            return 'Address format not supported'

            

              
                Copy
              
            
          

4. Valutahantering

Om din applikation involverar ekonomiska transaktioner, lagra användarens föredragna valuta och använd den för att visa priser och belopp. Använd ett bibliotek som `babel` för att formatera valutavärden enligt användarens språk.

Exempel:

            from babel.numbers import format_currency

class CustomUser(AbstractUser):
    #...
    preferred_currency = models.CharField(max_length=3, default='USD')

    def get_formatted_price(self, amount):
        return format_currency(amount, self.preferred_currency, locale='en_US')  # Adjust locale as needed
            

              
                Copy
              
            
          

5. Datavalidering

Implementera robust datavalidering för att säkerställa att användarinput är giltig och konsekvent. Använd Djangos inbyggda validatorer eller skapa anpassade validatorer för att upprätthålla dataintegritet.

Exempel:

            from django.core.validators import RegexValidator

class CustomUser(AbstractUser):
    #...
    phone_number = models.CharField(
        max_length=20,
        blank=True,
        validators=[
            RegexValidator(
                regex=r'^\+?\d{9,15}$',
                message="Phone number must be entered in the format: '+999999999'. Up to 15 digits allowed."
            ),
        ]
    )
            

              
                Copy
              
            
          

6. Säkerhetsöverväganden

Lösenordshashning: Djangos autentiseringssystem använder starka lösenordshashningsalgoritmer som standard. Se till att du använder den senaste versionen av Django för att dra nytta av de senaste säkerhetsuppdateringarna.

Tvåfaktorsautentisering (2FA): Implementera 2FA för att lägga till ett extra säkerhetslager till användarkonton. Det finns olika Django-paket tillgängliga för detta, till exempel `django-otp`. Detta är särskilt viktigt när du hanterar känslig användardata eller finansiella transaktioner.

Dataskydd: Följ bästa praxis för dataskydd och integritet, särskilt när du hanterar känslig användarinformation. Följ relevanta dataskyddsbestämmelser, såsom GDPR och CCPA. Överväg datakryptering, anonymisering och tokeniseringstekniker.

7. Testning

Skriv omfattande enhetstester och integrationstester för att säkerställa att din anpassade användarmodell fungerar som förväntat och att ditt autentiseringssystem är säkert. Testa olika scenarier, inklusive giltig och ogiltig användarinput, arbetsflöden för återställning av lösenord och behörighetskontroller.

8. Dokumentation

Dokumentera din anpassade användarmodell och ditt autentiseringssystem noggrant. Detta gör det lättare för andra utvecklare att förstå och underhålla din kod. Inkludera information om syftet med varje fält, autentiseringsflödet och eventuella säkerhetsöverväganden.

Avancerade tekniker och överväganden

1. Anpassade användarhanterare

Som demonstrerats i exemplet `AbstractBaseUser` är anpassade användarhanterare avgörande för att skapa och hantera användare. De låter dig definiera anpassad logik för att skapa användare, till exempel att ställa in standardvärden för vissa fält eller utföra ytterligare validering.

2. Proxy-modeller

Proxy-modeller låter dig lägga till metoder till användarmodellen utan att ändra databasschemat. Detta kan vara användbart för att lägga till anpassad logik eller beräkningar som är specifika för din applikation.

3. Utöka användarmodellen med en profilmodell

Istället för att lägga till många fält direkt i användarmodellen kan du skapa en separat profilmodell som har en en-till-en-relation med användarmodellen. Detta kan hjälpa till att hålla din användarmodell ren och organiserad.

            from django.db import models
from django.conf import settings

class UserProfile(models.Model):
    user = models.OneToOneField(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name='profile')
    # Additional fields
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True)

            

              
                Copy
              
            
          

Kom ihåg att skapa en signal för att automatiskt skapa en UserProfile när en användare skapas:

            from django.db.models.signals import post_save
from django.dispatch import receiver
from django.conf import settings
from .models import UserProfile

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)

@receiver(post_save, sender=settings.AUTH_USER_MODEL)
def save_user_profile(sender, instance, **kwargs):
    instance.profile.save()

            

              
                Copy
              
            
          

4. Single Sign-On (SSO)

För större organisationer eller applikationer som kräver integration med andra tjänster, överväg att implementera Single Sign-On (SSO) med protokoll som OAuth 2.0 eller SAML. Django tillhandahåller flera paket som förenklar SSO-integration, till exempel `django-allauth`.

5. Granskningsloggning

Implementera granskningsloggning för att spåra användaraktivitet och ändringar i användardata. Detta kan vara användbart för säkerhetsövervakning, efterlevnad och felsökning. Paket som `django-auditlog` kan hjälpa till att automatisera denna process.

Slutsats

Att skapa och implementera anpassade användarmodeller i Django ger den flexibilitet och kontroll du behöver för att bygga robusta och skalbara autentiseringssystem, särskilt för globala applikationer. Genom att följa bästa praxis som beskrivs i den här guiden kan du säkerställa att din applikation är väl rustad för att hantera olika användarkrav, upprätthålla dataintegritet och ge en säker och användarvänlig upplevelse för användare runt om i världen. Kom ihåg att noggrant planera din implementering, överväga dina användares behov och prioritera säkerhet i varje steg i processen. Att välja mellan `AbstractBaseUser` och `AbstractUser` beror på vilken nivå av anpassning som krävs. För betydande ändringar erbjuder `AbstractBaseUser` mer kontroll. För enkla tillägg ger `AbstractUser` en smidigare övergång. Grundlig testning är avgörande för att säkerställa att den anpassade användarmodellen integreras sömlöst med resten av din Django-applikation och uppfyller alla säkerhetskrav. Anamma bästa praxis för internationalisering, lokalisering och tidszonhantering för att leverera en verkligt global upplevelse. Detta kommer att bidra avsevärt till framgången och antagandet av din applikation på olika marknader över hela världen.